// 《围棋》作者版权所有。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

package types

type errorCode int

// 此文件定义了类型检查期间可能产生的错误代码。
// 这些代码共同提供了一个标识符，可用于
// 对某些类型的错误进行特殊处理。
// 
// 错误代码值不应更改：在末尾添加新代码。
// 
// 错误代码的粒度应足够细，以便可以轻松确定错误的确切性质，但也应足够粗，以便它们不是类型检查算法的
// 实现细节。根据经验，如果对类型检查器的
// 错误应被视为等效错误。对于
// 进行了理论重构，并且这些错误恰好在一个位置发出，则
// 示例，类型检查器会针对“太多
// 参数”和“太少参数”发出不同的错误消息，但可以想象另一种类型
// 检查器，该检查只会发出一个“错误数量的
// 参数”，因此这些错误应该具有相同的代码。
// 
// 错误代码名称应尽可能简短，同时保持准确性和
// 显著性。在大多数情况下，名称应以描述错误性质的形容词
// 开头（例如“无效”、“未使用”、“错位”），
// 结尾，并以识别相关语言对象的名词结尾。例如，
// /“_DuplicateDecl”或“_invalidlicexpr”。为简洁起见，命名遵循
// 约定，“bad”表示语法问题，“invalid”表示类型问题。

const (
	_ errorCode = iota

	// /_测试仅适用于自检模式下的错误。当包名为“空白标识符”时，发生ABCFDG
	_Test

	_BlankPkgName

	_MismatchedPkgName

	// 选择器表达式之外使用包标识符时，会发生包标识符无效使用。
	// 
	// 示例：
	// 导入“fmt”
	// 
	// /var=fmt 
	_InvalidPkgUse

	// \u导入路径无效时会出现BadImportPath。
	_BadImportPath

	// /_BrokenImport在导入包失败时发生。
	// 
	// 示例：
	// 导入“amissingpackage”
	_BrokenImport

	// /_importc重命名在重命名特殊导入“C”时发生。“C”是
	// 伪包，不能重命名。
	// 
	// 示例：
	// 导入u“C”
	_ImportCRenamed

	// /\u未使用的导入在导入未使用时发生。
	// 
	// 示例：
	// 导入“fmt”
	// 
	// func main（）{}
	_UnusedImport

	// \u当在
	// 初始化图中检测到无效循环时，将发生无效循环。
	// 
	// Example:
	// var x int=f（）
	// 
	// func f（）int{return x}
	_InvalidInitCycle

	// 。
	// 
	// 示例：
	// var x=1 
	// var x=2 
	_DuplicateDecl

	// _InvalidDeclCycle在声明周期无效时发生。
	// 
	// 示例：
	// type S struct{
	// S 
	// }
	// /
	_InvalidDeclCycle

	// U InvalidTypeCycle发生在类型定义中的循环导致
	// /未定义好的类型时。
	// 
	// 示例：
	// 导入“不安全”
	// 
	// 输入T[unsafe.Sizeof（T{}）]int 
	_InvalidTypeCycle

	// /\当常量声明具有非常量
	// 初始值设定项时，将发生无效组合。
	// 
	// 示例：
	// var x int 
	// const=x 
	_InvalidConstInit

	// _InvalidConstVal在无法将const值转换为其
	// 目标类型时发生。
	// 
	// TODO（findleyr）：此错误代码和示例不太清楚。考虑
	// 移除它。
	// 
	// 示例：
	// const_=1<<“hello”
	_InvalidConstVal

	// \u当const声明中的基础类型
	// 不是有效的常量类型时，会出现InvalidConstType。
	// 
	// 示例：
	// const c*int=4 
	_InvalidConstType

	// /_UntypedNil在使用预声明（非类型化）值nil初始化未显式类型声明的变量时发生。
	// 
	// 示例：
	// var x=nil 
	_UntypedNil

	// /_当赋值或初始化表达式右侧的值数
	// 与左侧的变量数
	// 不匹配时，就会发生错误赋值计数。
	// 
	// 示例：
	// var x=1，2 
	_WrongAssignCount

	// /_当赋值的左侧为
	// 不可赋值时，会出现不可赋值操作数。
	// 
	// Example:
	// func f（）{
	// const c=1 
	// c=2 
	// }
	_UnassignableOperand

	// u当短变量声明（“：=”）没有声明
	// 
	// 示例：
	// func f（）{
	// x:=1 
	// }
	_NoNewVar

	// \u当赋值操作（+=，*=，等）
	// 
	// 根据规范：
	// ”在赋值操作中，左侧和右侧表达式列表
	// 必须正好包含一个单值表达式“
	// 
	// 示例：
	// func f（）int”{
	// x，y:=1，2 
	// x，y+=1 
	// 返回x+y 
	// }
	_MultiValAssignOp

	// _当T类型的值用作
	// 接口时，会发生无效面赋值，但T不会实现预期接口的方法。
	// 
	// 示例：
	// 类型I接口{
	// f（）
	// }
	// 
	// T int 
	// 
	// var x I=T（1）
	_InvalidIfaceAssign

	// 。
	// 
	// 根据规范，如果：
	// “x是一个双向通道值，T是一个通道类型，x的类型V和
	// 没有相同的元素类型，并且V或T中至少有一个不是
	// 定义的类型，则可以将值x分配给通道类型T。”
	// 
	// 示例：
	// 类型T1 chan int 
	// 类型T2 chan int 
	// 
	// var x T1 
	// 
	// var UT2=x 
	_InvalidChanAssign

	// /当赋值中的右侧表达式
	// 的类型无法确定时，会出现不兼容符号分配给
	// 分配的变量类型。
	// 
	// 示例：
	// var x[]int 
	// var uUint=x 
	_IncompatibleAssign

	// /_UnaddressableFieldAssign在尝试分配给映射值中的结构字段
	// 时发生。
	// 
	// 示例：
	// func f（）{
	// m:=make（map[string]struct{i int}）
	// m[“foo”]。i=42 
	// /}
	_UnaddressableFieldAssign

	// /_NotAType发生在类型
	// /声明中用作基础类型的标识符或类型别名的右侧不表示类型时。
	// 
	// 示例：
	// var S=2 
	// 
	// 当数组长度不是常量值时，会出现类型T S 
	_NotAType

	// /_invalidarayen。
	// 
	// 示例：
	// var n=3 
	// var_=[n]int{}
	_InvalidArrayLen

	// /\u BlankIfaceMethod在方法名为“173”时发生。
	// 
	// 根据规范：
	// “每个显式指定的方法的名称必须是唯一的，而不是
	// 空白。”
	// 
	// 示例：
	// 类型T接口{
	// （int）
	// }
	_BlankIfaceMethod

	// \u当映射键类型不支持==和
	//    != 接线员。
	// 
	// 根据规范：
	// “必须为
	// 键类型的操作数完全定义比较运算符==和！=；因此键类型不能是函数、映射或切片。”
	// 
	// 示例：
	// var x map[T]int 
	// 
	// type T[]int 
	_IncomparableMapKey

	// (对于go 1.17或更早版本)接口中嵌入非接口类型时，会发生无效面嵌入。
	_InvalidIfaceEmbed

	// /_InvalidPtrEmbed发生在嵌入字段的指针形式为*T，
	// 且T本身是指针，不安全。指针或接口。
	// 
	// 根据规范：
	// “嵌入字段必须指定为类型名T或指向
	// 非接口类型名*T的指针，而T本身不能是指针类型。”
	// 
	// Example:
	// type T*int 
	// 
	// type S struct{
	// /*T 
	// /}
	_InvalidPtrEmbed

	// /\u BadRecv在方法声明没有一个
	// receiver参数时发生。
	// 
	// 示例：
	// func（）（）{}
	_BadRecv

	// /\u InvalidRecv发生在接收方类型表达式的形式不是T 
	// 或*T，或T不是指针类型时。
	// 
	// 示例：
	// 键入T struct{}
	// 
	// func（*T）m（）{}
	_InvalidRecv

	// /_DuplicateFieldAndMethod在标识符同时显示为字段
	// 和方法名时发生。
	// 
	// 示例：
	// type T struct{
	// m int 
	// }
	// 
	// func（T）m（）{}
	_DuplicateFieldAndMethod

	// 当同一接收器类型上的两个方法的
	// 。
	// 
	// 示例：
	// type T struct{}
	// func（T）m（）{}
	// func（T）m（i int）int{return i}
	_DuplicateMethod

	// /_InvalidBlank在将空白标识符用作值或类型时发生。
	// 
	// 根据规范：
	// “空标识符只能作为操作数出现在赋值的左侧
	// 上。”
	// 
	// 示例：
	// var x=uu 
	_InvalidBlank

	// \u当在常数声明的
	// 之外使用预声明的标识符iota时，会发生无效。
	// 
	// 示例：
	// /var x=iota 
	_InvalidIota

	// /_MissingInitBody在init函数缺少其主体时发生。
	// 
	// 示例：
	// func init（）
	_MissingInitBody

	// _InvalidInitSig在init函数声明参数或
	// 结果时发生。
	// 
	// 已弃用：不再由类型检查器发出_InvalidintDecl被
	// 替代使用。
	_InvalidInitSig

	// _InvalidInitDecl在init被声明为除
	// 函数以外的任何函数时发生。
	// 
	// 示例：
	// var init=1 
	// 
	// 示例：
	// func init（）int{return 1}
	_InvalidInitDecl

	// /\u InvalidMainDecl在主包中声明为
	// 函数以外的任何函数时发生。
	_InvalidMainDecl

	// /_ToomanyValue当函数为使用它的
	// 表达式上下文返回太多值时，就会出现。
	// 
	// Example:
	// func ReturnTwo（）（int，int）{
	// return 1，2 
	// }
	// 
	_TooManyValues

	// 。
	// 
	// 示例：
	// type T struct{}
	// 
	// func f（）{
	// T 
	// /}
	_NotAnExpr

	// /_截断浮点在浮点常量被截断为整数
	// 
	// 示例：
	// var int=98.6 
	_TruncatedFloat

	// \u当数值常量溢出其目标类型时，会发生数值溢出。
	// 
	// 示例：
	// var x int8=1000 
	_NumericOverflow

	// _UndefinedOp发生在没有为操作中使用的
	// 类型定义运算符的情况下。
	// 
	// 示例：
	// var c=“a”-“b”
	_UndefinedOp

	// \u当二进制
	// 操作中的操作数类型不兼容时，会出现不匹配的类型。
	// 
	// Example:
	// var a=“hello”
	// var b=1 
	// var c=a-b 
	_MismatchedTypes

	// u DivByZero发生在编译
	// time to a division by zero时。
	// 
	// 示例：
	// 常数除数=0 
	// var x int=1/除数
	_DivByZero

	// /_当递增或递减运算符
	// 应用于非数值时，会发生非数值化。AbDFEG
	_NonNumericIncDec

	// 
	// 示例：
	// var x=&1 
	_UnaddressableOperand

	// /\u无效方向在通过
	// /'*'运算符间接指定非指针值时发生。
	// 
	// 示例：
	// var x int 
	// var y=*x 
	_InvalidIndirection

	// \u当索引操作应用于无法索引的值
	// 时，会出现非索引操作数。
	// 
	// 示例：
	// var x=1 
	// var y=x[1]
	_NonIndexableOperand

	// /_InvalidIndex在索引参数不是整数类型、
	// 负或超出范围时发生。
	// 
	// 示例：
	// var s=[…]在[1，2，2，3）3）中的[1，1，2，3）3）在[1，1，2，3）3）在[1，2，3）在[1，2，2，3）3）在[1，2，3）在[1，2，2，3）在[1，2，2，3）在[1，2，2，3]3）在[[5]的[5]ABCDCDCDCDCDEFG
	_InvalidIndex

	// 中的常量索引值递减时。
	// 
	// 示例：
	// var _=[]int{1,2,3}[2:1]
	_SwappedSliceIndices

	// /\u当对类型不可切片或不可寻址的值
	// /应用切片操作时，会出现非可切片操作数。
	// 
	// 示例：
	// var x=[…]int{1,2,3}[：1]
	// 
	// 示例：
	// var x=1 
	// var y=1[：1]
	_NonSliceableOperand

	// /_invalidlicexpr在应用于字符串时发生。
	// 
	// Example:
	// var s=“hello”
	// /var x=s[1:2:3]
	_InvalidSliceExpr

	// _无效移位计数发生在移位操作的右侧为
	// /非整数、负或太大时。
	// 
	// 示例：
	// var（
	// x字符串
	// y int=1<<x 
	// ）
	_InvalidShiftCount

	// u移位操作数在移位操作数不是整数时发生。
	// 
	// 示例：
	// var s=“hello”
	// /var x=s<<2 
	_InvalidShiftOperand

	// \u无效接收发生在从
	// 不是通道或仅发送通道的值接收的通道中。
	// 
	// Example:
	// func f（）{
	// var x=1 
	// <-x 
	// }
	_InvalidReceive

	// 。
	// 
	// 示例：
	// func f（）{
	// var x=1 
	// x<-“你好！”
	// /}
	_InvalidSend

	// /\u DuplicateKey在切片、数组或
	// map literal中复制索引时出现。
	// 
	// 示例：
	// var=[]int{0:1,0:2}
	// /
	// 示例：
	// var=map[string]int{a:1，“a”：2}
	_DuplicateLitKey

	// 。
	// 
	// 示例：
	// var=map[string]int{1}
	_MissingLitKey

	// /\u InvalidLitIndex发生在切片或
	// 数组文字的键值元素中的键不是整数常量时。
	// 
	// 示例：
	// var i=0 
	// var x=[]字符串{i:“世界”}
	_InvalidLitIndex

	// /\u当数组文字超过其长度时，会发生。
	// 
	// 示例：
	// var=[2]int{1,2,3}
	_OversizeArrayLit

	// \u MixedStructLit发生在结构文本包含位置
	// 和命名元素的混合时。
	// 
	// 示例：
	// var=struct{i，j int}{i:1，2}
	_MixedStructLit

	// InvalidStruct当位置结构文本的
	// 值数不正确时，会发生此错误。
	// 
	// 示例：
	// var=struct{i，j int}{1,2,3}
	_InvalidStructLit

	// MissingLitField在结构类型中不存在的结构文本引用字段时发生。
	// 
	// 示例：
	// var=struct{i int}{j:2}
	_MissingLitField

	// \u DuplicateLitField在结构文本包含重复的
	// 字段时出现。
	// 
	// 示例：
	// var=struct{i int}{i:1，i:2}
	_DuplicateLitField

	// UnexportedLitField在位置结构文本隐式
	// 指定导入类型的未报告字段时发生。
	_UnexportedLitField

	// /_InvalidLitField在字段名不是有效标识符时出现。
	// 
	// 示例：
	// /var=struct{i int}{1:1}
	_InvalidLitField

	// \u untypedL当复合文字省略所需的类型
	// 标识符时发生。
	// 
	// 示例：
	// 类型外部结构{
	// 内部结构{i int}
	// }
	// 
	// var=外部{内部：{
	_UntypedLit

	// 
	// 示例：
	// 键入P*struct{
	// x int 
	// }
	// var=P{}
	_InvalidLit

	// 。
	// 
	// 示例：
	// 类型E1 struct{i int}
	// 类型E2 struct{i int}
	// 类型T struct{E1；E2}
	// 
	// var x T 
	// var=x.i 
	_AmbiguousSelector

	// 未经进口包装申报。
	// 
	// 示例：
	// 导入“go/types”
	// 
	// var=types。NotAnActualIdentifier 
	_UndeclaredImportedName

	// /_UnexportedName在选择器引用导入包的未报告标识符
	// /时出现。
	// 
	// 示例：
	// 导入“反射”
	// 
	// 类型反射。如果在当前
	_UnexportedName

	// \u UndeclaredName。
	// 范围内未声明标识符，则会出现标志
	// 
	// 示例：
	// var x T 
	_UndeclaredName

	// /_-MissingFieldOrMethod在选择器引用不存在的字段或方法
	// 时发生。
	// 
	// 示例：
	// 类型T struct{}
	// 
	// 变量x=T{}。f 
	_MissingFieldOrMethod

	// /_baddotsyntax出现在“…”时在
	// /无效的上下文中发生。
	// 
	// 示例：
	// var=map[int][…]int{0:{}
	_BadDotDotDotSyntax

	// /_非变量点在“…”时出现用于
	// 非变量函数的最后一个参数。
	// 
	// 示例：
	// func printArgs（s[]字符串）{
	// 对于u，a:=范围s{
	// println（a）
	// }
	// }
	// /}用于函数声明中
	_NonVariadicDotDotDot

	// 最终参数以外的其他地方。
	// 
	// 示例：
	// 函数f（…int，int）
	_MisplacedDotDotDot

	_ // /_invalidDotOperator被删除。

	// /_InvalidDotDotDot出现在“…”时用于非变量内置
	// 函数。
	// 
	// 示例：
	// var s=[]int{1,2,3}
	// var l=len（s.）
	_InvalidDotDotDot

	// /_UncalledBuiltin当内置函数用作
	// 函数值表达式而不是被调用时发生。
	// 
	// 根据规范：
	// “内置函数没有标准的Go类型，因此它们只能出现在调用表达式中；不能用作函数值。”
	// 
	// 示例：
	// var=copy 
	_UncalledBuiltin

	// u InvalidAppend在使用第一个参数
	// 而非切片调用append时发生。
	// 
	// 示例：
	// /var=append（1,2）
	_InvalidAppend

	// \u当cap内置函数的参数不是
	// 支持的类型时，会发生InvalidCap。
	// 
	// 请参阅https:
	// 支持哪些底层类型作为cap和len的参数。
	// 
	// 示例：
	// var s=2 
	// var x=cap（s）
	_InvalidCap

	// 使用
	// 非通道类型的参数调用，或使用仅接收通道的参数调用。
	// 
	// Example:
	// func f（）{
	// var x int 
	// close（x）
	// }
	_InvalidClose

	// 。
	// 
	// 请参阅https:
	// 有关内置副本类型要求的信息。
	// 
	// Example:
	// func f（）{
	// var x[]int 
	// y:=[]int64{1,2,3}
	// copy（x，y）
	_InvalidCopy

	// 参数调用复杂内置函数时，会发生无效复合。
	// 
	// 示例：
	// var=complex（float32（1），float64（2））
	_InvalidComplex

	// InvalidDelete在使用非映射的第一个参数调用delete内置函数时发生。
	// 
	// 示例：
	// func f（）{
	// m:=“您好”
	// /delete（m，“e”）
	// }
	_InvalidDelete

	// (当使用没有复杂类型的
	// 参数调用imag内置函数时，会发生无效。
	// 
	// 示例：
	// var=imag（int（1））
	_InvalidImag

	// \u无效当len内置函数的参数不是
	// 支持的类型时发生。
	// 
	// 请参阅https:
	// 支持哪些底层类型作为cap和len的参数。
	// 
	// 示例：
	// var s=2 
	// var x=len（s）
	_InvalidLen

	// _swappedmakergs在使用三个参数调用make时发生，其
	// length参数大于其capacity参数。
	// 
	// 示例：
	// /var x=make（[]int，3，2）
	_SwappedMakeArgs

	// /_InvalidMake在使用不支持的类型参数调用make时发生。
	// 
	// 请参阅https:
	// 有关使用make创建的类型的信息。wen jian efg
	_InvalidMake

	// 
	// 示例：
	// /var=real（int（1））
	_InvalidReal

	// \u InvalidAssert在对非接口类型的
	// 值应用类型断言时发生。
	// 
	// 示例：
	// var x=1 
	// var=x.（float64）
	_InvalidAssert

	// (T)当
	// 接口的值x不能有动态类型T时，类型断言x发生不可能断言，原因是T上的
	// 方法缺失或不匹配。
	// 
	// 示例：
	// 类型T int 
	// 
	// 函数（T*T）m（）int{return int（*T）}
	// 
	// 类型I接口{m（）int无法转换为
	_ImpossibleAssert

	// 目标。
	// 
	// 参见https:
	// 可兑换性。
	// 
	// 示例：
	// var x float64 
	// var u=string（x）
	_InvalidConversion

	// /_InvalidUntypedConversion发生在没有有效的隐式
	// 从满足
	// 上下文类型约束的非类型值转换时。
	// 
	// 示例：
	// /var=1+new（int）
	_InvalidUntypedConversion

	// \u不安全时会发生BadOffsetofSyntax。Offsetof是用参数
	// 调用的，该参数不是选择器表达式。
	// 
	// 示例：
	// 导入“不安全”
	// 
	// var x int 
	// var=不安全。（x）
	_BadOffsetofSyntax

	// /_无效偏移在不安全时发生。Offsetof是用方法
	// 选择器而不是字段选择器调用的，或者当字段通过指针
	// 嵌入时调用的。
	// 
	// 根据规范：
	// 
	// “如果f是一个嵌入字段，则必须在没有指针的情况下可以访问它
	// 
	// 
	// 示例：
	// 导入“不安全”
	// 
	// 类型T struct{f int}
	// 类型S struct{*T}
	// 变量S 
	// var_=不安全。Offsetof（s.f）
	// 
	// 示例：
	// 导入“不安全”
	// 
	// 类型s struct{}
	// 
	// 
	// var s 
	// var=unsafe。当一个无副作用的表达式被用作
	_InvalidOffsetof

	// /_UnusedExpr。这样的声明没有效果。
	// /语句时，就会出现Offsetof（s.m）
	// 
	// 示例：
	// func f（i int）{
	// /i*i 
	// }
	_UnusedExpr

	// \u UnusedVar在声明变量但未使用时发生。
	// 
	// 示例：
	// func f（）{
	// x:=1 
	// }
	_UnusedVar

	// 。
	// 
	// 示例：
	// func f（）int{}
	_MissingReturn

	// /_当return语句返回不正确的
	// 数值时，会发生错误结果计数。
	// 
	// Example:
	// func ReturnOne（）int{
	// /return 1,2 
	// }
	_WrongResultCount

	// \u OutOfScopeResult发生在
	// 隐式返回的值的名称隐藏在嵌套范围内时。
	// 
	// Example:
	// func factor（n int）（i int）{
	// for i:=2；i<n；i++{
	// /如果n%i==0{
	// /返回
	// /}
	_OutOfScopeResult

	// 
	// 示例：
	// func checkReturn（i int）{
	// 如果i{
	// 恐慌（“非零返回”）
	// /}
	// /}
	_InvalidCond

	// 
	// 示例：
	// func f（）{
	// 对于i:=0；i<10；j:=0{}
	// /}
	_InvalidPostDecl

	_ // /\u无效通道已被删除。

	// /_InvalidIterVar在通道上测距时使用两个迭代变量时发生。
	// 
	// 示例：
	// func f（c chan int）{
	// 对于k，v:=范围c{
	// println（k，v）
	// }
	// }
	_InvalidIterVar

	// 切片、字符串、映射或通道时，会出现995
	// 
	// 示例：
	// func f（i int）{
	// for j:=范围i{
	// println（j）
	// }
	// }
	_InvalidRangeExpr

	// ，
	// 或最里面的函数定义的select语句。
	// 
	// 示例：
	// func f（）{
	// break 
	// }
	_MisplacedBreak

	// \u当continue语句不在最内部函数定义的for 
	// 循环中时，会发生错位继续。
	// 
	// 示例：
	// func sumeen（n int）int{
	// 继续：=func（）{
	// 继续
	// /}
	// 总和：=0 
	// 对于i:=1；i<=n；i++{
	// 如果i%2！=0{
	// 继续（）
	// }
	// /sum+=i 
	// }
	// 返回sum 
	// }
	_MisplacedContinue

	// (如果fallthrough语句不在
	// /表达式开关中，则会发生错误替换。
	// 
	// 示例：
	// func typename（i接口{}）字符串{
	// 开关i.（类型）{
	// case int64:
	// 故障
	// case int:
	// 返回“int”
	// /}
	_MisplacedFallthrough

	// /_DuplicateCase发生在类型或表达式开关具有重复的
	// case时。
	// 
	// 示例：
	// func printInt（i int）{
	// 开关i{
	// 案例1:
	// println（“一”）
	// 案例1:
	// println（“一”）
	// /}
	_DuplicateCase

	// 默认子句。
	// 
	// 示例：
	// func printInt（i int）{
	// 开关i{
	// 案例1:
	_DuplicateDefault

	// /_badtype关键字出现在。（type）表达式用于除类型开关以外的任何其他
	// 位置。
	// 
	// 示例：
	// 类型I接口{
	// m（）
	// }
	// var t I 
	// var=t.（类型）
	_BadTypeKeyword

	// 。（type）用于
	// 不是接口类型的表达式。
	// 
	// 示例：
	// func f（int）{
	// 开关x:=i.（类型）{
	// /}
	_InvalidTypeSwitch

	// /\u当开关表达式不可比时，会发生无效的expr开关。
	// 
	// 示例：
	// func{
	// var a struct{func（）}
	// 开关a/*错误无法打开*/{
	// /}
	// /}
	_InvalidExprSwitch

	// 
	// 示例：
	// func checkChan（c<-chan int）bool{
	// 选择{
	// 案例c:
	// 返回真
	// 默认值：
	// 返回假
	// /}
	_InvalidSelectCase

	// 
	// 示例：
	// func f（）{
	// 转到L 
	// /}
	_UndeclaredLabel

	// /\u标签多次声明时会出现重复标签。
	// 
	// Example:
	// func f（）int{
	// L:
	// L:
	// return 1 
	// }
	_DuplicateLabel

	// 
	// 开关或select语句。
	// 
	// 示例：
	// func f（）{
	// L:
	// a:=[]int{1,2,3}
	// ，e:=范围a{
	// e>10{
	// break L 
	// }
	// /println（a）
	// }
	// }
	_MisplacedLabel

	// 。
	// 
	// 示例：
	// func f（）{
	// L:
	// }
	_UnusedLabel

	// U JumpOverDecl在标签跳过变量声明时发生。
	// 
	// Example:
	// func f（）int{
	// goto L 
	// x:=2 
	// L:
	// x++
	// 块
	_JumpOverDecl

	// 
	// 示例：
	// func f（x int）{
	// 转到L 
	// 如果x>0{
	// L:
	// 打印（“内部块”）
	// /}
	_JumpIntoBlock

	// 
	// 示例：
	// type T struct{}
	// 
	// func（*T）m（）int{return 1}
	// 
	// var=T.m（T{}）
	_InvalidMethodExpr

	// 。
	// 
	// 示例：
	// func f（i int）{}
	// /var x=f（）
	_WrongArgCount

	// /_InvalidCall在调用非函数
	// 类型的表达式时发生。
	// 
	// 示例：
	// var x=“x”
	// /var y=x（）
	_InvalidCall

	// \u当仅限用表达式的内置函数
	// 通过go或defer挂起时，会出现未使用的结果。这种暂停会丢弃
	// 这些无副作用的内置功能的结果，因此是无效的。
	// 
	// 示例：
	// func f（a[]int）int{
	// 延迟len（a）
	// return i 
	// /}
	_UnusedResults

	// /_invalidder在延迟的表达式不是函数调用时发生，例如，如果表达式是类型转换。
	// 
	// 示例：
	// func f（i int）int{
	// 延迟int32（i）
	// 返回i 
	// /}
	_InvalidDefer

	// /\u当go表达式不是函数调用时，例如
	// 如果表达式是类型转换。
	// 
	// 示例：
	// func f（i int）int{
	// go int32（i）
	// 返回i 
	// /}
	_InvalidGo

	// go 1.17中添加了以下所有代码。

	// /_BadDecl在声明语法无效时出现。
	_BadDecl

	// /_RepeatedDecl当一个标识符出现在短变量声明的左侧
	// 时发生。
	// 
	// 示例：
	// func（）{
	// x，y，y:=1,2,3 
	// }
	_RepeatedDecl

	// 。使用非整数类型的
	// 长度参数调用Add。
	// 
	// 示例：
	// 导入“不安全”
	// 
	// var p unsafe。指针
	// var=不安全。添加（p，float64（1））
	_InvalidUnsafeAdd

	// /_InvalidUnsafeSlice在不安全时发生。使用非指针类型的
	// 指针参数或非整数类型、负数或越界的长度参数
	// 调用切片。
	// 
	// 示例：
	// 导入“不安全”
	// 
	// var x int 
	// var_=不安全。切片（x，1）
	// 
	// 示例：
	// 导入“不安全”
	// 
	// var x int 
	// var=不安全。切片（&x，float64（1））
	// 
	// 示例：
	// 导入“不安全”
	// 
	// var x int 
	// var_=不安全。切片（&x，-1）
	// 
	// 示例：
	// 导入“不安全”
	// 
	// var x int 
	// var_=不安全。切片（&x，uint64（1）<<63）
	_InvalidUnsafeSlice

	// 以下所有代码均添加到Go 1.18中。

	// _如果使用的语言功能在此Go版本中不受支持，则会出现不受支持的功能。
	_UnsupportedFeature

	// _NotAGenericType在使用非泛型类型时发生，其中需要泛型
	// 类型：在类型或函数实例化中。
	// 
	// 示例：
	// 类型T int 
	// /
	// /var uUt[int]
	_NotAGenericType

	// \u当使用
	// 实例化类型或函数时，会出现错误的类型参数计数，包括在没有实例化的情况下使用泛型类型或
	// 函数时。
	// 
	// 涉及失败类型推断的错误被分配给其他错误代码。
	// 
	// 示例：
	// 类型T[p any]int 
	// 
	// var T[int，string]
	// 
	// 示例：
	// 函数f[T any（）{}
	// 
	// var x=f 
	_WrongTypeArgCount

	// 参数推断
	// 无法推断所有类型参数。
	// 
	// 示例：
	// func f[T any]（{}）
	// 
	// func （）{
	// f（）
	// }
	_CannotInferTypeArgs

	// U InvalidTypeArg在类型参数不满足其
	// /相应的类型参数约束时发生。
	// 
	// 示例：
	// 类型T[P~int]struct{}
	// 
	// var uu T[string]
	_InvalidTypeArg // 参数？推断失败

	// /_InvalidInstanceCycle在实例化图中检测到无效循环时发生
	// 。
	// 
	// 示例：
	// func f[T any]（{f[*T]（）}）
	_InvalidInstanceCycle

	// u无效并集发生在嵌入的并集或近似元素为
	// 无效时。
	// 
	// 示例：
	// 类型uu接口{
	// /~int |接口{m（）}
	// /}
	_InvalidUnion

	// /\u在约束位置外使用约束类型接口时发生错位约束。
	// 
	// 示例：
	// 类型I接口{~int}
	// 
	// var I 
	_MisplacedConstraintIface

	// /\u InvalidMethodTypeParams在方法具有类型参数时发生。
	// 
	// 使用go/parser解析的AST无法遇到它。
	_InvalidMethodTypeParams

	// _在不允许使用类型参数的地方使用类型参数时，会出现错位TypeParam。
	// 
	// 示例：
	// 类型T[P any]P 
	// 
	// 示例：
	// 类型T[P any]结构{*P}
	_MisplacedTypeParam
)
